This cog will listen for duck reactions on any message, and then:
- If the reaction was added by a staff member
- and the reaction was a duck
- and the message has not already been added to the #duck-pond

It will add the message to the #duck-pond and then add a green checkbox
to the original message to indicate that the message has been ponded.

Messages are added to the #duck-pond via webhook, so that they can
retain the appearance of having their original authors.

Once this checkmark has been added, the message will not be processed in
the future.

If the checkmark is removed and there are more than ducks_required ducks
on the message, the bot will automatically add the checkmark back.

However, if all reactions are removed, the bot does not have a
countermeasure for this. In order to implement a countermeasure, it
would be necessary to involve the API and the database.

Also gets started setting up for the final tests, which will require
more mockwork.

Basically I suck at this and I can't get this return_value thing to work.
I'll have Ves look at it to resolve it.

As of right now, multiple tests are failing.

By default, a mocked value is considered `truthy` in Python, like all
non-empty/non-zero/non-None values in Python. This means that if an
attribute is not explicitly set on a mock, it will evaluate at as
truthy in a boolean context, since the mock will provide a truthy
mocked value by default.

This is not the best default value for the `bot` attribute of our
MockMember type, since members are rarely bots. It makes much more
intuitive sense to me to consider a member to not be a bot, unless we
explicitly set `bot=True`.

This commit sets that sensible default value that can be overwritten
by passing `bot=False` to the constructor or setting the `object.bot`
attribute to `False` after the creation of the mock.

As stated from the start, our intention is to add custom mock types
as we need them for testing. While writing tests for DuckPond, I
noticed that we did not have a mock type for Attachments, so I added
one with this commit.

In addition, I think it's a very sensible for MockMessage to have an
empty list as a default value for the `attachements` attribute. This
is equal to what `discord.Message` returns for a message without
attachments and makes sure that if you don't explicitely add an
attachment to a message, `MockMessage.attachments` tests as falsey.

To allow for separate testing of the code that relays messages to the
duck pond, I have moved this part of the code from the event listener
to a separate method. The overall logic has remained unchanged.

In addition, I've kaizened to things:

- Removed unnecessary f-string without interpolation;

- Removed double negative (not item not in list)

The `DuckPond.on_raw_message_add` event listener makes an API call to
fetch the message the reaction was added to. However, we don't need
to fetch the message if the reaction that was added is not relevant
to the duck pond. To prevent such unnecessary API calls, I have moved
the code that checks for the relevance of the reaction event to
before the code that fetches the message.

I have added a special mock that follows the specifications of a
`discord.User` instance. This is useful, since `Users` have less
attributes available than `discord.Members`. Since this difference
in availability of information can be important, we should not use
a `MockMember` to mock a `discord.user`.

The new AsyncIteratorMock no longer needs an additional method to be
used with a Mock object.

I have added a mock type to mock `discord.Webhook` instances. Note
that the current type is specifically meant to mock webhooks that
use an AsyncAdaptor and therefore has AsyncMock/coroutine mocks for
the "maybe-coroutine" methods specified in the `discord.py` docs.

This commit adds unit tests that provide a full branch coverage of
the `bot.cogs.duck_pond` file.

#621

I've changed to unit tests according to the comments made on the
issue. Most changes are straightforward enough, but, for context,
see the PR linked above.